import axios from 'axios'
import { ElLoading, ElMessage } from 'element-plus'

// API配置
const API_CONFIG = {
    baseURL: 'http://localhost:8080/api',
    timeout: 10000
}

// 创建axios实例
const apiClient = axios.create({
    baseURL: API_CONFIG.baseURL,
    timeout: API_CONFIG.timeout,
    headers: {
        'Content-Type': 'application/json'
    }
})

// 请求拦截器
apiClient.interceptors.request.use(
    config => {
        // 可以在这里添加token等认证信息
        // const token = localStorage.getItem('token');
        // if (token) {
        //     config.headers.Authorization = `Bearer ${token}`;
        // }
        
        // 显示加载状态
        ElLoading.service({
            lock: true,
            text: '加载中...',
            background: 'rgba(0, 0, 0, 0.7)'
        })
        
        return config
    },
    error => {
        ElLoading.service().close()
        return Promise.reject(error)
    }
)

// 响应拦截器
apiClient.interceptors.response.use(
    response => {
        ElLoading.service().close()
        return response.data
    },
    error => {
        ElLoading.service().close()
        
        let errorMessage = '网络错误，请稍后重试'
        
        if (error.response) {
            switch (error.response.status) {
                case 400:
                    errorMessage = error.response.data.message || '请求参数错误'
                    break
                case 401:
                    errorMessage = '未授权访问'
                    // 可以在这里处理登录过期
                    break
                case 403:
                    errorMessage = '禁止访问'
                    break
                case 404:
                    errorMessage = '资源不存在'
                    break
                case 500:
                    errorMessage = error.response.data.message || '服务器内部错误'
                    break
                default:
                    errorMessage = `错误代码: ${error.response.status}`
            }
        } else if (error.request) {
            errorMessage = '网络连接失败，请检查网络'
        }
        
        ElMessage.error(errorMessage)
        return Promise.reject(error)
    }
)

// 供应商相关API
export const supplierAPI = {
    // 分页查询供应商列表
    getSupplierPage(params) {
        return apiClient.get('/supplier/page', { params })
    },
    
    // 获取供应商详情
    getSupplierById(id) {
        return apiClient.get(`/supplier/${id}`)
    },
    
    // 新增供应商
    addSupplier(data) {
        return apiClient.post('/supplier', data)
    },
    
    // 更新供应商
    updateSupplier(id, data) {
        return apiClient.put(`/supplier/${id}`, data)
    },
    
    // 删除供应商
    deleteSupplier(id) {
        return apiClient.delete(`/supplier/${id}`)
    },
    
    // 获取供应商类型选项
    getSupplierTypes() {
        return apiClient.get('/supplier/types')
    },
    
    // 获取状态选项
    getSupplierStatuses() {
        return apiClient.get('/supplier/statuses')
    },
    
    // 获取所有供应商列表（不分页）
    getAllSuppliers() {
        return apiClient.get('/supplier/all')
    }
}

// 客户相关API
export const customerAPI = {
    // 分页查询客户列表
    getCustomerPage(params) {
        return apiClient.get('/customer/page', { params })
    },
    
    // 获取客户详情
    getCustomerById(id) {
        return apiClient.get(`/customer/${id}`)
    },
    
    // 新增客户
    addCustomer(data) {
        return apiClient.post('/customer', data)
    },
    
    // 更新客户
    updateCustomer(id, data) {
        return apiClient.put(`/customer/${id}`, data)
    },
    
    // 删除客户
    deleteCustomer(id) {
        return apiClient.delete(`/customer/${id}`)
    },
    
    // 获取状态选项
    getCustomerStatuses() {
        return apiClient.get('/customer/statuses')
    },
    
    // 获取业务经理列表
    getManagerList() {
        return apiClient.get('/customer/managers')
    },
    
    // 获取所有客户列表（不分页）
    getAllCustomers() {
        return apiClient.get('/customer/all')
    }
}

// 系统相关API
export const systemAPI = {
    // 健康检查
    healthCheck() {
        return apiClient.get('/hello')
    },
    
    // 系统状态
    getSystemStatus() {
        return apiClient.get('/hello/status')
    },
    
    // 系统信息
    getSystemInfo() {
        return apiClient.get('/hello/info')
    }
}

// 员工相关API
export const employeeAPI = {
    // 分页查询员工列表
    getEmployeePage(params) {
        return apiClient.get('/employee/page', { params })
    },
    
    // 获取员工详情
    getEmployeeById(id) {
        return apiClient.get(`/employee/${id}`)
    },
    
    // 新增员工
    addEmployee(data) {
        return apiClient.post('/employee', data)
    },
    
    // 更新员工
    updateEmployee(id, data) {
        return apiClient.put(`/employee/${id}`, data)
    },
    
    // 删除员工
    deleteEmployee(id) {
        return apiClient.delete(`/employee/${id}`)
    },
    
    // 获取员工身份选项
    getEmployeeRoles() {
        return apiClient.get('/employee/roles')
    },
    
    // 获取状态选项
    getEmployeeStatuses() {
        return apiClient.get('/employee/statuses')
    },
    
    // 获取所有员工列表（不分页）
    getAllEmployees() {
        return apiClient.get('/employee/all')
    }
}

// 报价单相关API
export const quotationAPI = {
    // 分页查询报价单列表
    getQuotationPage(params) {
        return apiClient.get('/quotations', { params })
    },
    
    // 获取报价单详情
    getQuotationById(id) {
        return apiClient.get(`/quotations/${id}`)
    },
    
    // 创建报价单
    createQuotation(data) {
        return apiClient.post('/quotations', data)
    },
    
    // 更新报价单
    updateQuotation(id, data) {
        return apiClient.put(`/quotations/${id}`, data)
    },
    
    // 删除报价单
    deleteQuotation(id) {
        return apiClient.delete(`/quotations/${id}`)
    },
    
    // 生成合同
    generateContract(id) {
        return apiClient.post(`/quotations/${id}/generate-contract`)
    },
    
    // 提交报价单
    submitQuotation(id) {
        return apiClient.post(`/quotations/${id}/submit`)
    },
    
    // 保存草稿
    saveDraft(data) {
        return apiClient.post('/quotations/draft', data)
    },
    
    // 获取客户选项列表
    getCustomerOptions() {
        return apiClient.get('/quotations/customer-options')
    },
    
    // 获取业务员选项列表
    getEmployeeOptions() {
        return apiClient.get('/quotations/employee-options')
    },
    
    // 更新报价单状态
    updateQuotationStatus(id, status) {
        return apiClient.put(`/quotations/${id}/status`, { status })
    }
}

// 合同相关API
export const contractAPI = {
    // 分页查询合同列表
    getContractPage(params) {
        return apiClient.get('/contracts', { params })
    },
    
    // 获取合同详情
    getContractById(id) {
        return apiClient.get(`/contracts/${id}`)
    },
    
    // 合同审核
    auditContract(id, data) {
        return apiClient.post(`/contracts/${id}/audit`, data)
    },
    
    // 预览合同HTML
    previewContractHtml(id) {
        return apiClient.get(`/contracts/${id}/preview`)
    },
    
    // 下载合同PDF
    downloadContractPdf(id) {
        return apiClient.get(`/contracts/${id}/download`, {
            responseType: 'blob'
        })
    },
    

}

// 外发加工相关API
export const outsourcingAPI = {
    // 分页查询外发加工列表
    getOutsourcingPage(params) {
        return apiClient.get('/outsourcing', { params })
    },
    
    // 获取外发加工详情
    getOutsourcingById(id) {
        return apiClient.get(`/outsourcing/${id}`)
    },
    
    // 创建外发单
    createOutsourcing(data) {
        return apiClient.post('/outsourcing', data)
    },
    
    // 删除外发单
    deleteOutsourcing(id) {
        return apiClient.delete(`/outsourcing/${id}`)
    },
    
    // 更新外发状态
    updateOutsourcingStatus(id, data) {
        return apiClient.put(`/outsourcing/${id}/status`, data)
    },
    
    // 获取供应商选项列表
    getSupplierOptions() {
        return apiClient.get('/outsourcing/supplier-options')
    },

    // 获取可用于外发加工的报价记录列表
    getAvailableQuotationsForOutsourcing() {
        return apiClient.get('/outsourcing/available-quotations')
    },

    // 获取可入库的外发单列表
    getAvailableOutsourcingForInbound(params) {
        return apiClient.get('/outsourcing/available-for-inbound', { params })
    }
}

// 入库管理相关API
export const inboundAPI = {
    // 获取可入库的订单列表
    getAvailableOrders(params) {
        return apiClient.get('/warehouse/inbound/available-orders', { params })
    },
    
    // 创建入库单（基于报价单）
    createInbound(data) {
        return apiClient.post('/warehouse/inbound', data)
    },
    
    // 基于外发单创建入库单
    createOutsourcingInbound(data) {
        return apiClient.post('/warehouse/inbound/outsourcing', data)
    },
    
    // 获取入库记录列表
    getInboundRecords(params) {
        return apiClient.get('/warehouse/inbound/records', { params })
    },
    
    // 获取入库单详情
    getInboundById(id) {
        return apiClient.get(`/warehouse/inbound/${id}`)
    },
    
    // 删除入库单
    deleteInbound(id) {
        return apiClient.delete(`/warehouse/inbound/${id}`)
    },
    
    // 获取报价明细已入库总数量
    getTotalInboundQuantityByQuotationItem(quotationItemId) {
        return apiClient.get(`/warehouse/inbound/total-quantity/${quotationItemId}`)
    },
    
    // 获取外发单已入库总数量
    getTotalInboundQuantityByOutsourcing(outsourcingId) {
        return apiClient.get(`/warehouse/inbound/outsourcing/${outsourcingId}/total-quantity`)
    },
    
    // 生成厂内编号
    generateFactoryNo() {
        return apiClient.get('/warehouse/generate-factory-no')
    }
}

// 工具函数
export const apiUtils = {
    // 处理API响应
    handleResponse(response) {
        if (response.code === 200) {
            return response.data
        } else {
            throw new Error(response.message || '操作失败')
        }
    },
    
    // 格式化日期
    formatDate(dateStr) {
        if (!dateStr) return ''
        const date = new Date(dateStr)
        return date.toLocaleString('zh-CN', {
            year: 'numeric',
            month: '2-digit',
            day: '2-digit',
            hour: '2-digit',
            minute: '2-digit'
        })
    },
    
    // 供应商类型映射
    getSupplierTypeLabel(type) {
        const typeMap = {
            'material': '原材料',
            'equipment': '设备',
            'service': '服务',
            'other': '其他'
        }
        return typeMap[type] || type
    },
    
    // 状态映射
    getStatusLabel(status) {
        const statusMap = {
            'active': '启用',
            'inactive': '停用'
        }
        return statusMap[status] || status
    },
    
    // 获取状态标签类型
    getStatusTagType(status) {
        return status === 'active' ? 'success' : 'danger'
    },
    
    // 获取供应商类型标签类型
    getSupplierTypeTagType(type) {
        const typeTagMap = {
            'material': 'success',
            'equipment': 'warning',
            'service': 'info',
            'other': 'default'
        }
        return typeTagMap[type] || 'default'
    },
    
    // 表单验证规则
    getValidationRules() {
        return {
            supplierCode: [
                { required: true, message: '请输入供应商代码', trigger: 'blur' },
                { min: 1, max: 20, message: '长度在 1 到 20 个字符', trigger: 'blur' }
            ],
            supplierName: [
                { required: true, message: '请输入供应商名称', trigger: 'blur' },
                { min: 1, max: 50, message: '长度在 1 到 50 个字符', trigger: 'blur' }
            ],
            supplierType: [
                { required: true, message: '请选择供应商类型', trigger: 'change' }
            ],
            contactName: [
                { required: true, message: '请输入联系人姓名', trigger: 'blur' },
                { min: 1, max: 30, message: '长度在 1 到 30 个字符', trigger: 'blur' }
            ],
            contactPhone: [
                { required: true, message: '请输入联系人电话', trigger: 'blur' },
                { min: 1, max: 20, message: '长度在 1 到 20 个字符', trigger: 'blur' },
                { pattern: /^[1][3,4,5,6,7,8,9][0-9]{9}$/, message: '请输入正确的手机号码', trigger: 'blur' }
            ]
        }
    },
    
    // 客户表单验证规则
    getCustomerValidationRules() {
        return {
            customerCode: [
                { max: 20, message: '长度不能超过 20 个字符', trigger: 'blur' }
            ],
            customerName: [
                { max: 30, message: '长度不能超过 30 个字符', trigger: 'blur' }
            ],
            contactPhone: [
                { max: 20, message: '长度不能超过 20 个字符', trigger: 'blur' },
                { pattern: /^$|^[1][3,4,5,6,7,8,9][0-9]{9}$/, message: '请输入正确的手机号码格式', trigger: 'blur' }
            ],
            companyName: [
                { max: 100, message: '长度不能超过 100 个字符', trigger: 'blur' }
            ]
        }
    }
} 